/**
 * 饮食管理相关API
 */
import request from '@/common/request'
import config from '@/common/config'
import mockData from '../mock/dietData.js'
import { getToken, getUserInfo } from '../utils/auth.js'

// 添加token获取辅助函数


/**
 * 获取食物分类列表
 * @returns {Promise} 返回食物分类列表
 */
export function getFoodCategories() {
  // 使用实际API
  return request.get('/api/diet/categories')
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  return Promise.resolve({
    code: 0,
    data: [
      { id: 1, name: '谷物类', icon: '/static/images/category/grains.png' },
      { id: 2, name: '蔬菜类', icon: '/static/images/category/vegetable.png' },
      { id: 3, name: '水果类', icon: '/static/images/category/fruit.png' },
      { id: 4, name: '蛋白质类', icon: '/static/images/category/protein.png' },
      { id: 5, name: '奶制品', icon: '/static/images/category/dairy.png' },
      { id: 6, name: '饮料类', icon: '/static/images/category/beverage.png' }
    ]
  })
  */
}

/**
 * 搜索食物
 * @param {Object} params 搜索参数
 * @param {String} params.keyword 搜索关键词
 * @param {Number} params.page 页码
 * @param {Number} params.pageSize 每页数量
 * @returns {Promise} 返回搜索结果
 */
export function searchFood(params) {
  // 使用实际API
  return request.get('/api/diet/foods/search', params)
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  const mockData = [
    // 省略mock数据...
  ]
  
  return Promise.resolve({
    code: 0,
    data: {
      list: mockData,
      total: mockData.length,
      page: params.page || 1,
      pageSize: params.pageSize || 10
    }
  })
  */
}

/**
 * 根据分类获取食物列表
 * @param {Object} params 查询参数
 * @param {Number} params.categoryId 分类ID
 * @param {Number} params.page 页码
 * @param {Number} params.pageSize 每页数量
 * @returns {Promise} 返回食物列表
 */
export function getFoodByCategory(params) {
  // 使用实际API
  return request.get(`/api/diet/foods/category/${params.categoryId}`, {
    page: params.page,
    pageSize: params.pageSize
  })
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  const mockData = {
    // 省略mock数据...
  }
  
  const categoryId = params.categoryId
  const list = mockData[categoryId] || []
  
  return Promise.resolve({
    code: 0,
    data: {
      list,
      total: list.length,
      page: params.page || 1,
      pageSize: params.pageSize || 10
    }
  })
  */
}

/**
 * 获取食物详情
 * @param {Object} params 查询参数
 * @param {Number} params.id 食物ID
 * @returns {Promise} 返回食物详情
 */
export function getFoodDetail(params) {
  // 使用实际API
  return request.get(`/api/diet/foods/${params.id}`)
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  const mockData = {
    // 省略mock数据...
  }
  
  const id = params.id
  return Promise.resolve({
    code: 0,
    data: mockData[id] || null
  })
  */
}

/**
 * 添加饮食记录
 * @param {Object} data 饮食记录数据
 * @returns {Promise} 返回添加结果
 */
export function addDietRecord(data) {
  // 获取当前的token，可能包含用户信息
  const token = getToken();
  // 尝试获取用户信息
  const userInfo = getUserInfo();
  
  // 验证必要的数据字段，确保字段存在且不为null
  const validatedData = {
    // 尝试从用户信息获取用户ID，如果不存在则使用默认值6
    userId: userInfo ? userInfo.id : 6,
    // 食物信息
    ...(data.foodId ? { foodId: data.foodId } : {}),
    ...(data.name ? { foodName: data.name } : {}),
    // 基本数据
    amount: parseInt(data.amount) || 100, // 确保是整数
    mealType: typeof data.mealType === 'number' ? data.mealType : 1, // 确保是数字
    // 营养成分
    ...(data.calories ? { calories: parseFloat(data.calories) } : {}),
    ...(data.carbs ? { carbohydrate: parseFloat(data.carbs) } : {}),
    ...(data.protein ? { protein: parseFloat(data.protein) } : {}),
    ...(data.fat ? { fat: parseFloat(data.fat) } : {}),
    // 其他信息
    ...(data.image ? { foodImage: data.image } : {}),
    ...(data.remark ? { remark: data.remark } : { remark: '' })
  };
  
  // 如果既没有foodId也没有foodName，返回错误
  if (!validatedData.foodId && !validatedData.foodName) {
    console.error('添加饮食记录失败: 缺少食物信息');
    return Promise.reject({
      code: -1,
      msg: '添加饮食记录失败: 缺少食物信息'
    });
  }
  
  // 构建meal_time字段
  if (data.date && data.time) {
    validatedData.mealTime = `${data.date} ${data.time}`;
  } else {
    const now = new Date();
    const dateStr = now.toISOString().split('T')[0];
    const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
    validatedData.mealTime = `${dateStr} ${timeStr}`;
  }
  
  // 记录日志以便调试
  console.log('添加饮食记录, 提交数据:', JSON.stringify(validatedData));
  
  // 使用实际API - 直接发送数据，不做额外处理
  return request.post('/api/diet/records', validatedData, {
    headers: {
      'Authorization': token ? `Bearer ${token}` : '',
      'Content-Type': 'application/json'
    }
  })
  .then(response => {
    console.log('添加饮食记录成功, 响应:', JSON.stringify(response));
    return response;
  })
  .catch(error => {
    console.error('添加饮食记录请求失败, 错误:', JSON.stringify(error));
    // 格式化错误响应
    return {
      code: -1,
      msg: error.message || '添加饮食记录失败',
      error: error
    };
  });
}

/**
 * 更新饮食记录
 * @param {Object} data 饮食记录数据
 * @returns {Promise} 返回更新结果
 */
export function updateDietRecord(data) {
  // 使用实际API
  return request.put(`/api/diet/records/${data.id}`, data)
}

/**
 * 删除饮食记录
 * @param {Object} params 查询参数
 * @param {Number} params.id 记录ID
 * @returns {Promise} 返回删除结果
 */
export function deleteDietRecord(params) {
  // 使用实际API
  return request.delete(`/api/diet/records/${params.id}`)
}

/**
 * 获取饮食记录
 * @param {Object} params 查询参数
 * @param {Number} params.userId 用户ID
 * @param {String} params.date 日期，格式yyyy-MM-dd
 * @returns {Promise} 返回饮食记录
 */
export function getDietRecords(params) {
  // 使用实际API
  return request.get('/api/diet/records', params)
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  // 从mock数据中获取或生成数据
  const date = params.date || new Date().toISOString().split('T')[0]
  const mockRecord = mockData.dietRecords.find(record => record.date === date) || {
    id: 999,
    date,
    meals: [],
    totalDailyCalories: 0,
    totalDailyCarbs: 0,
    remark: ''
  }
  
  return Promise.resolve({
    code: 0,
    data: mockRecord
  })
  */
}

/**
 * 获取用户饮食记录列表
 * @param {Object} params 查询参数
 * @param {Number} params.userId 用户ID
 * @param {String} params.startDate 开始日期，格式yyyy-MM-dd
 * @param {String} params.endDate 结束日期，格式yyyy-MM-dd
 * @param {Number} params.page 页码
 * @param {Number} params.pageSize 每页数量
 * @returns {Promise} 返回饮食记录列表
 */
export function getDietRecordsList(params) {
  // 使用实际API
  return request.get('/api/diet/records/list', params)
}

/**
 * 获取特定餐次的饮食记录
 * @param {Object} params 查询参数
 * @param {Number} params.userId 用户ID
 * @param {String} params.date 日期，格式yyyy-MM-dd
 * @param {String} params.mealType 餐次类型：breakfast, lunch, dinner, snack
 * @returns {Promise} 返回特定餐次的饮食记录
 */
export function getDietRecordsByMealType(params) {
  console.log('调用getDietRecordsByMealType, 参数:', JSON.stringify(params));
  
  // 检查必要参数
  if (!params || !params.userId || !params.date || !params.mealType) {
    console.error('getDietRecordsByMealType参数错误:', params);
    return Promise.reject({
      code: -1,
      msg: '请求参数不完整',
      data: null
    });
  }
  
  // 确保userId是数字类型
  if (typeof params.userId === 'string') {
    params.userId = parseInt(params.userId);
  }
  
  // 使用POST方法解决405 Method Not Allowed错误
  return request.post('/api/diet/records/meal', params)
    .then(response => {
      console.log('getDietRecordsByMealType响应成功:', JSON.stringify(response).substring(0, 200));
      return response;
    })
    .catch(error => {
      console.error('getDietRecordsByMealType请求失败:', error);
      // 返回格式化后的错误对象
      return {
        code: error.code || -1,
        msg: error.msg || '获取饮食记录失败',
        data: null
      };
    });
}

/**
 * 获取饮食统计数据
 * @param {Object} params 查询参数
 * @param {Number} params.userId 用户ID
 * @param {String} params.startDate 开始日期，格式yyyy-MM-dd
 * @param {String} params.endDate 结束日期，格式yyyy-MM-dd
 * @returns {Promise} 返回统计数据
 */
export function getDietStats(params) {
  // 使用实际API
  return request.get('/api/diet/stats', params)
}

/**
 * 获取推荐食谱
 * @param {Object} params 查询参数
 * @param {Number} params.page 页码
 * @param {Number} params.pageSize 每页数量
 * @returns {Promise} 返回食谱列表
 */
export function getRecommendRecipes(params = {}) {
  // 使用实际API
  return request.get('/api/diet/recipes/recommend', params)
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  return Promise.resolve({
    code: 0,
    data: {
      list: mockData.dietRecommendations,
      total: mockData.dietRecommendations.length,
      page: params.page || 1,
      pageSize: params.pageSize || 10
    }
  })
  */
}

/**
 * 根据餐类型获取食谱列表
 * @param {Object} params 查询参数
 * @param {String} params.mealType 餐类型：breakfast,lunch,dinner,snack
 * @param {Number} params.page 页码
 * @param {Number} params.pageSize 每页数量
 * @returns {Promise} 返回食谱列表
 */
export function getRecipesByMealType(params) {
  // 使用实际API
  return request.get(`/api/diet/recipes/mealType/${params.mealType}`, {
    page: params.page,
    pageSize: params.pageSize
  })
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  const mealType = params.mealType
  const recipes = mockData.dietRecommendations.filter(recipe => recipe.mealType === mealType)
  
  return Promise.resolve({
    code: 0,
    data: {
      list: recipes,
      total: recipes.length,
      page: params.page || 1,
      pageSize: params.pageSize || 10
    }
  })
  */
}

/**
 * 获取食谱详情
 * @param {Object} params 查询参数
 * @param {Number} params.id 食谱ID
 * @returns {Promise} 返回食谱详情
 */
export function getRecipeDetail(params) {
  // 参数验证
  if (!params) {
    console.error('getRecipeDetail: 参数对象为空');
    return Promise.reject({
      code: -1,
      msg: '参数对象为空'
    });
  }
  
  if (params.id === undefined || params.id === null) {
    console.error('getRecipeDetail: 缺少必要参数id');
    return Promise.reject({
      code: -1,
      msg: '缺少食谱ID参数'
    });
  }
  
  // 确保ID是数字
  const id = Number(params.id);
  if (isNaN(id)) {
    console.error('getRecipeDetail: ID不是有效数字', params.id);
    return Promise.reject({
      code: -1,
      msg: 'ID不是有效数字'
    });
  }
  
  // 打印请求信息
  console.log('请求食谱详情, ID:', id);
  
  // 使用实际API
  return request.get(`/api/diet/recipes/${id}`)
    .then(response => {
      // 打印响应信息
      console.log('食谱详情响应:', response);
      
      // 检查响应数据
      if (response.code === 0 && !response.data) {
        console.warn('食谱详情响应成功但数据为空, ID:', id);
        return {
          code: 0,
          msg: '食谱不存在',
          data: null
        };
      }
      
      // 处理返回的数据，确保食材信息正确
      if (response.code === 0 && response.data) {
        // 如果meals数组为空，但存在foods数组，则将foods赋值给meals
        if ((!response.data.meals || response.data.meals.length === 0) && 
            response.data.foods && response.data.foods.length > 0) {
          response.data.meals = response.data.foods;
        }
        
        // 如果meals数组为空，但存在ingredients数组，则将ingredients赋值给meals
        if ((!response.data.meals || response.data.meals.length === 0) && 
            response.data.ingredients && response.data.ingredients.length > 0) {
          response.data.meals = response.data.ingredients;
        }
        
        // 确保数据结构完整
        if (!response.data.meals) {
          response.data.meals = [];
        }
        
        console.log('处理后的食谱详情数据:', JSON.stringify(response.data).substring(0, 200));
      }
      
      return response;
    })
    .catch(error => {
      console.error('获取食谱详情失败:', error);
      return {
        code: -1,
        msg: '获取食谱详情失败: ' + (error.msg || error.message || '未知错误'),
        error
      };
    });
}

/**
 * 获取饮食知识问答题目
 * @returns {Promise} 返回问答题目
 */
export function getDietQuizQuestions() {
  // 模拟数据
  return Promise.resolve({
    code: 0,
    data: [
      {
        id: 1,
        question: '以下哪种食物的升糖指数最低？',
        options: [
          { id: 'A', text: '白米饭' },
          { id: 'B', text: '全麦面包' },
          { id: 'C', text: '土豆' },
          { id: 'D', text: '西兰花' }
        ],
        answer: 'D',
        explanation: '西兰花几乎不含碳水化合物，升糖指数接近于0。而白米饭、全麦面包和土豆都含有较多的碳水化合物，会导致血糖上升。'
      },
      {
        id: 2,
        question: '糖尿病患者应该完全避免摄入碳水化合物吗？',
        options: [
          { id: 'A', text: '是的，应该完全避免' },
          { id: 'B', text: '不是，但应该控制数量和质量' },
          { id: 'C', text: '只要注射胰岛素就可以随意摄入' },
          { id: 'D', text: '只有1型糖尿病需要控制碳水摄入' }
        ],
        answer: 'B',
        explanation: '糖尿病患者不需要完全避免碳水化合物，但应该控制摄入量，并优先选择低升糖指数的碳水化合物，如全谷物、豆类等。'
      },
      {
        id: 3,
        question: '以下哪种烹饪方式最适合糖尿病患者？',
        options: [
          { id: 'A', text: '油炸' },
          { id: 'B', text: '红烧' },
          { id: 'C', text: '清蒸' },
          { id: 'D', text: '烧烤' }
        ],
        answer: 'C',
        explanation: '清蒸是最健康的烹饪方式之一，可以保留食物的营养成分，同时不需要添加额外的油脂，有助于控制热量摄入。'
      },
      {
        id: 4,
        question: '以下哪种水果的升糖指数最高？',
        options: [
          { id: 'A', text: '苹果' },
          { id: 'B', text: '西瓜' },
          { id: 'C', text: '草莓' },
          { id: 'D', text: '橙子' }
        ],
        answer: 'B',
        explanation: '西瓜的升糖指数较高，约为72-80，而苹果、草莓和橙子的升糖指数相对较低，分别约为36、40和40左右。'
      },
      {
        id: 5,
        question: '餐后多久测量血糖最合适？',
        options: [
          { id: 'A', text: '立即测量' },
          { id: 'B', text: '餐后1小时' },
          { id: 'C', text: '餐后2小时' },
          { id: 'D', text: '餐后4小时' }
        ],
        answer: 'C',
        explanation: '餐后2小时测量血糖是最常用的方法，可以了解食物对血糖的影响。餐后2小时血糖正常值应低于7.8mmol/L。'
      }
    ]
  })
  
  // 实际接口
  // return request.get('/diet/quiz/questions')
}

/**
 * 提交问答得分
 * @param {Object} data 得分数据
 * @param {Number} data.score 分数
 * @param {Number} data.correctCount 正确题目数
 * @param {Number} data.totalCount 总题目数
 * @returns {Promise} 返回提交结果
 */
export function submitQuizScore(data) {
  // 模拟数据
  return Promise.resolve({
    code: 0,
    message: '提交成功',
    data: {
      healthPoints: 10, // 获得健康积分
      totalPoints: 120  // 总健康积分
    }
  })
  
  // 实际接口
  // return request.post('/diet/quiz/score', data)
}

/**
 * 获取食谱游戏数据
 * @returns {Promise} 返回食谱游戏数据
 */
export function getRecipeGameData() {
  // 模拟数据
  return Promise.resolve({
    code: 0,
    data: {
      mealOptions: [
        { id: 1, name: '荤菜', options: ['清蒸鱼', '蒸鸡胸肉', '水煮牛肉', '香煎三文鱼'] },
        { id: 2, name: '素菜', options: ['西兰花', '炒青菜', '凉拌黄瓜', '烤番薯'] },
        { id: 3, name: '主食', options: ['糙米饭', '全麦面包', '燕麦粥', '杂粮饭'] },
        { id: 4, name: '汤品', options: ['番茄蛋汤', '紫菜汤', '冬瓜排骨汤', '鸡蛋豆腐汤'] }
      ],
      bestCombinations: [
        { main: '清蒸鱼', vegetable: '西兰花', staple: '糙米饭', soup: '紫菜汤' },
        { main: '蒸鸡胸肉', vegetable: '炒青菜', staple: '燕麦粥', soup: '番茄蛋汤' },
        { main: '香煎三文鱼', vegetable: '烤番薯', staple: '全麦面包', soup: '鸡蛋豆腐汤' }
      ]
    }
  })
  
  // 实际接口
  // return request.get('/diet/game/recipe')
}

/**
 * 提交食谱游戏结果
 * @param {Object} data 游戏结果
 * @param {Object} data.combination 玩家的食谱组合
 * @param {Boolean} data.isMatch 是否匹配最佳组合
 * @returns {Promise} 返回提交结果
 */
export function submitRecipeGame(data) {
  // 模拟数据
  return Promise.resolve({
    code: 0,
    message: data.isMatch ? '恭喜您，这是一个健康的搭配！' : '这个组合还可以更健康哦！',
    data: {
      healthPoints: data.isMatch ? 10 : 5, // 获得健康积分
      totalPoints: 120  // 总健康积分
    }
  })
  
  // 实际接口
  // return request.post('/diet/game/recipe/submit', data)
}

/**
 * 获取所有食谱列表
 * @returns {Promise} 返回食谱列表
 */
export function getAllRecipes() {
  console.log('请求所有食谱列表');
  
  // 使用正确的API路径
  return request.get('/api/diet/recipes/recommend')
    .then(response => {
      // 打印响应信息
      console.log('食谱列表响应:', response);
      
      // 检查响应数据
      if (response.code === 0 && (!response.data || !response.data.list)) {
        console.warn('食谱列表响应成功但数据结构不完整');
        // 尝试兼容处理
        if (response.data && Array.isArray(response.data)) {
          return {
            code: 0,
            msg: 'success',
            data: {
              list: response.data,
              total: response.data.length,
              page: 1,
              pageSize: response.data.length
            }
          };
        }
      }
      
      return response;
    })
    .catch(error => {
      console.error('获取食谱列表失败:', error);
      return {
        code: -1,
        msg: '获取食谱列表失败: ' + (error.msg || error.message || '未知错误'),
        error
      };
    });
  
  // 以下是mock数据，可以在API未开发完成时使用
  /*
  return Promise.resolve({
    code: 0,
    data: [
      {
        id: 1,
        name: '清蒸鱼配蔬菜',
        image: '/static/images/placeholder.png',
        desc: '低脂肪高蛋白，适合血糖控制',
        calories: 320,
        carbs: 16,
        protein: 45,
        fat: 12
      },
      // ... 其他食谱
    ]
  })
  */
}

/**
 * 添加食谱
 * @param {Object} data 食谱数据
 * @param {String} data.title 食谱标题(必填)
 * @param {String} data.description 食谱描述
 * @param {String} data.image 食谱图片URL
 * @param {String} data.mealType 餐类型(breakfast/lunch/dinner/snack)
 * @param {String} data.tips 食谱小贴士
 * @param {Number} data.prepTime 准备时间(分钟)
 * @param {Number} data.cookTime 烹饪时间(分钟)
 * @param {Array} data.foods 食材列表，每个食材包含foodId, quantity, unit等属性
 * @param {Array} data.steps 步骤列表，每个步骤包含content, stepOrder等属性
 * @returns {Promise} 返回添加结果
 */
export function addRecipe(data) {
  // 获取当前的token，可能包含用户信息
  const token = getToken();
  
  // 验证必要的数据字段
  if (!data.title || data.title.trim() === '') {
    console.error('添加食谱失败: 缺少标题');
    return Promise.reject({
      code: -1,
      msg: '食谱标题不能为空'
    });
  }
  
  // 检查食材数据，确保每个食材都有foodId字段
  const validFoods = Array.isArray(data.foods) ? 
    data.foods.filter(food => food && typeof food.foodId === 'number' && food.foodId > 0) : 
    [];
  
  if (validFoods.length === 0) {
    console.warn('添加食谱: 没有有效的食材数据');
  } else {
    console.log('有效食材数据:', JSON.stringify(validFoods));
  }
  
  // 构建请求数据，按照后端API期望的格式
  const requestData = {
    title: data.title.trim(),
    description: data.description || '',
    image: data.image || '',
    mealType: data.mealType || '',
    tips: data.tips || '',
    prepTime: data.prepTime || 10, // 默认10分钟
    cookTime: data.cookTime || 20, // 默认20分钟
    foods: validFoods,
    steps: Array.isArray(data.steps) ? data.steps : []
  };
  
  // 记录日志以便调试
  console.log('添加食谱, 提交数据:', JSON.stringify(requestData));
  
  // 使用实际API
  return request.post('/api/diet/recipes', requestData, {
    headers: {
      'Authorization': token ? `Bearer ${token}` : '',
      'Content-Type': 'application/json'
    }
  })
  .then(response => {
    console.log('添加食谱成功, 响应:', JSON.stringify(response));
    return response;
  })
  .catch(error => {
    console.error('添加食谱请求失败, 错误:', JSON.stringify(error));
    // 格式化错误响应
    return {
      code: -1,
      msg: error.message || '添加食谱失败',
      error: error
    };
  });
} 